package com.sz.util;

import com.sz.pojo.frame.ZiDian;
import com.sz.service.frame.ZiDianService;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Collection;

public class ToolStr {
    public static void main(String arg[]) {
        //创建第一个用户的密码
        // System.out.println(ToolStr.encoderByMd5("123","986524"));;
        // ArrayList<Double> similarlist = new ArrayList<>();
        // similarlist.add(11d);
        // similarlist.add(51d);
        // similarlist.add(12d);
        // similarlist.add(1d);
        //
        // // System.out.println(similarlist.stream().max(Comparator.comparing(u->u)).get());
        // // System.out.println(similarlist.stream().max(Comparator.comparingDouble(u->u)).get());
        //
        // String document = "算法可大致分为基本算法、数据结构的算法、数论算法、计算几何的算法、图的算法、动态规划以及数值分析、加密算法、排序算法、检索算法、随机化算法、并行算法、厄米变形模型、随机森林算法。\n" +
        //         "算法可以宽泛的分为三类，\n" +
        //         "一，有限的确定性算法，这类算法在有限的一段时间内终止。他们可能要花很长时间来执行指定的任务，但仍将在一定的时间内终止。这类算法得出的结果常取决于输入值。\n" +
        //         "二，有限的非确定算法，这类算法在有限的时间内终止。然而，对于一个（或一些）给定的数值，算法的结果并不是唯一的或确定的。\n" +
        //         "三，无限的算法，是那些由于没有定义终止定义条件，或定义的条件无法由输入的数据满足而不终止运行的算法。通常，无限算法的产生是由于未能确定的定义终止条件。";
        //
        // List<String> sentenceList = HanLP.extractSummary(document, 1);
        // System.out.println(sentenceList);

        // a.forEach(aDouble -> {
        //     System.out.println(aDouble);
        // });
        ZiDianService ziDianService = new ZiDianService();
        ZiDian z = new ZiDian();
        z.setName("石震");
        z.setPinyin("shizhen");

        ziDianService.save(z);
    }

    /**
     * 判断str是不是null，如果是null或者是空格返回true，否则返回false
     *
     * @param str
     * @return
     */
    public static boolean isEmpty(String str) {
        if (str == null || str.trim().length() <= 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * md5加密方法
     *
     * @param password
     * @return
     */
    public static String encoderByMd5(String password, String yan) {
        try {
            // 得到一个信息摘要器
            MessageDigest digest = MessageDigest.getInstance("md5");
            password = password + yan;
            byte[] result = digest.digest(password.getBytes());
            StringBuffer buffer = new StringBuffer();
            // 把没一个byte 做一个与运算 0xff;
            for (byte b : result) {
                // 与运算
                int number = b & 0xff;// 加盐
                String str = Integer.toHexString(number);
                if (str.length() == 1) {
                    buffer.append("0");
                }
                buffer.append(str);
            }
            // 标准的md5加密后的结果
            return buffer.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 判断objs数组是不是null，如果是null或者是空格返回true，否则返回false
     *
     * @param objs
     * @return
     */
    public static boolean isEmpty(Object... objs) {
        if (objs == null || objs.length <= 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断Collection容器是不是null，如果是null或者是空格返回true，否则返回false
     *
     * @param collection
     * @return
     */
    public static boolean isEmpty(Collection<?> collection) {
        if (collection == null || collection.size() <= 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断传入的字符串的第一个字母，如果是大写转为小写，如果不是返回原字符串。
     *
     * @param code
     * @return
     */
    public static String indexCodeLowerCase(String code) {
        char[] chars = new char[1];
        chars[0] = code.charAt(0);
        String str = code;
        String temp = new String(chars);
        if (chars[0] >= 'A' && chars[0] <= 'Z') {
            str = code.replaceFirst(temp, temp.toLowerCase());
        }
        return str;
    }

    /**
     * 将字符串表示的整型数据转化为int型。
     *
     * @param s 描述整型数据的字符串
     * @return 返回转换好的int，如果转换时出错则返回0。
     */
    public static int sToI(String s) {
        return sToI(s, 0);
    }

    /**
     * 将字符串表示的整型数据转化为int型。
     *
     * @param s            描述整型数据的字符串
     * @param defaultValue 转换失败时默认返回的值。
     * @return 返回转换好的int，如果转换时出错则返回defaultValue。
     */
    public static int sToI(String s, int defaultValue) {
        int i = defaultValue;
        try {
            i = Integer.parseInt(s);
        } catch (Exception e) {
        }
        return i;
    }

    /**
     * 将字符串表示的整型数据转化为double型。
     *
     * @param s 描述整型数据的字符串
     * @return 返回转换好的double，如果转换时出错则返回0。
     */
    public static double sToD(String s) {
        return sToD(s, 0d);
    }

    /**
     * 将字符串表示的整型数据转化为double型。
     *
     * @param s            描述整型数据的字符串
     * @param defaultValue 转换失败时默认返回的值。
     * @return 返回转换好的double，如果转换时出错则返回defaultValue。
     */
    public static double sToD(String s, double defaultValue) {
        Double d = defaultValue;
        try {
            d = Double.parseDouble(s);
        } catch (Exception e) {
        }
        if (d == null || d.isInfinite()) {
            d = defaultValue;
        }
        return d;
    }

    /**
     * 将字符串表示的整型数据转化为long型。
     *
     * @param s            描述整型数据的字符串
     * @param defaultValue 转换失败时默认返回的值。
     * @return 返回转换好的int，如果转换时出错则返回defaultValue。
     */
    public static long sToL(String s, long defaultValue) {
        long i = defaultValue;
        try {
            i = Long.parseLong(s);
        } catch (Exception e) {
        }
        return i;
    }

    /**
     * 将Long转为String
     * <p>
     * <pre>
     * &#64;param l 如果转换失败，返回""
     * </pre>
     *
     * @return
     */
    public static String L2S(Long l) {
        return L2S(l, "");
    }

    /**
     * 将Long转为String
     * <p>
     * <pre>
     * &#64;param l
     * &#64;param defaultStr--如果转换失败，返回此值
     * </pre>
     *
     * @return
     */
    public static String L2S(Long l, String defaultStr) {
        String str = null;
        try {
            str = l.toString();
        } catch (Exception e) {
            if (defaultStr == null) {
                str = "";
            } else {
                str = defaultStr;
            }
            // e.printStackTrace();
        }
        return str;
    }

    /**
     * 将Integer转为String
     * <p>
     * <pre>
     * &#64;param i 如果转换失败，返回""
     * </pre>
     *
     * @return
     */
    public static String I2S(Integer i) {
        return I2S(i, "");
    }

    /**
     * 将Integer转为String
     * <p>
     * <pre>
     * &#64;param i
     * &#64;param defaultStr--如果转换失败，返回此值
     * </pre>
     *
     * @return
     */
    public static String I2S(Integer i, String defaultStr) {
        String str = null;
        try {
            str = i.toString();
        } catch (Exception e) {
            if (defaultStr == null) {
                str = "";
            } else {
                str = defaultStr;
            }
            // e.printStackTrace();
        }
        return str;
    }

    /**
     * 模糊字符串<BR>
     * 用于sql模糊查询<BR>
     * 将字符串中的空格替换为“%”<BR>
     * 字符串两头添加“%” <BR>
     *
     * @param strSource 需要模糊的字符串
     * @return 模糊后的字符串
     */
    public static String fuzzy(String strSource) {
        String strResult = null;
        if (strSource == null || strSource.trim().length() == 0) {
            strResult = "%";
        } else {
            strResult = "%" + strSource.replace(' ', '%') + "%";
            strResult = strResult.replaceAll("%+", "%");
        }
        return strResult;
    }

}
